import { createRouter, createWebHashHistory, createWebHistory } from 'vue-router'

// 常量定义
const ROUTER_MODES = {
  HASH: 'hash',
  HISTORY: 'history'
}

const DEFAULT_PROJECT = 'project_01'
const PROJECT_STORAGE_KEY = 'activeProject'

/**
 * 获取当前路由模式
 * @returns {string} 路由模式 ('hash' | 'history')
 */
function getRouterMode() {
  return import.meta.env.VITE_ROUTER_MODE || ROUTER_MODES.HASH
}

/**
 * 创建路由历史对象
 * @param {string|null} mode - 指定的路由模式，为空时使用当前配置
 * @returns {object} Vue Router 历史对象
 */
function createRouterHistory(mode = null) {
  const routerMode = mode || getRouterMode()
  return routerMode === ROUTER_MODES.HISTORY ? createWebHistory() : createWebHashHistory()
}

const routerMode = getRouterMode()
const history = createRouterHistory()

/**
 * 获取当前激活的项目名
 * 优先级：URL参数 > 路径检测 > localStorage > 环境变量
 * @returns {string} 项目名称
 */
function getActiveProject() {
  // 1. 检查URL参数
  const urlProject = getProjectFromUrl()
  if (urlProject) {
    saveProjectToStorage(urlProject)
    return urlProject
  }
  
  // 2. 从当前路径检测项目名
  const pathProject = getProjectFromPath()
  if (pathProject) {
    saveProjectToStorage(pathProject)
    return pathProject
  }
  
  // 3. 从localStorage获取
  const storedProject = getProjectFromStorage()
  if (storedProject) {
    return storedProject
  }
  
  // 4. 使用默认项目
  return import.meta.env.VITE_ACTIVE_PROJECT || DEFAULT_PROJECT
}

/**
 * 从URL参数获取项目名
 * @returns {string|null} 项目名称或null
 */
function getProjectFromUrl() {
  const urlParams = new URLSearchParams(window.location.search)
  return urlParams.get('project')
}

/**
 * 从当前路径检测项目名
 * @returns {string|null} 项目名称或null
 */
function getProjectFromPath() {
  const currentPath = window.location.pathname || window.location.hash.replace('#', '')
  const pathSegments = currentPath.split('/').filter(Boolean)
  
  if (pathSegments.length > 0) {
    const potentialProject = pathSegments[0]
    const availableProjects = getAvailableProjectsSync()
    
    if (availableProjects.includes(potentialProject)) {
      return potentialProject
    }
  }
  
  return null
}

/**
 * 从localStorage获取项目名
 * @returns {string|null} 项目名称或null
 */
function getProjectFromStorage() {
  return localStorage.getItem(PROJECT_STORAGE_KEY)
}

/**
 * 保存项目名到localStorage
 * @param {string} projectName - 项目名称
 */
function saveProjectToStorage(projectName) {
  localStorage.setItem(PROJECT_STORAGE_KEY, projectName)
}

// 动态获取所有项目的路由模块
const projectRouteModules = import.meta.glob('/src/views/**/routes.js', { eager: false })

/**
 * 从路径中提取项目名称
 * @param {string} path - 文件路径
 * @returns {string|null} 项目名称或null
 */
function extractProjectName(path) {
  const match = path.match(/\/src\/views\/([^\/]+)\/routes\.js$/)
  return match ? match[1] : null
}

/**
 * 同步获取可用项目列表（用于路径检测）
 * @returns {string[]} 项目名称数组
 */
function getAvailableProjectsSync() {
  return Object.keys(projectRouteModules)
    .map(extractProjectName)
    .filter(Boolean)
}

/**
 * 获取可用的项目列表
 * @returns {string[]} 项目名称数组
 */
export function getAvailableProjects() {
  return Object.keys(projectRouteModules)
    .map(extractProjectName)
    .filter(Boolean)
}

/**
 * 加载指定项目的路由
 * @param {string} projectName - 项目名称
 * @returns {Promise<{routes: Array, config: Object, projectName: string}>} 项目路由信息
 */
async function loadProjectRoutes(projectName) {
  const modulePath = `/src/views/${projectName}/routes.js`
  
  // 检查项目是否存在
  if (!projectRouteModules[modulePath]) {
    console.warn(`项目 "${projectName}" 不存在，回退到默认项目`)
    return await loadProjectRoutes(DEFAULT_PROJECT)
  }
  
  try {
    const module = await projectRouteModules[modulePath]()
    const routes = module.default || module.routes || []
    const config = module.config || {}
    
    // 为路由添加项目前缀
    const projectRoutes = routes.map(route => addProjectPrefix(route, projectName))
    
    return {
      routes: projectRoutes,
      config,
      projectName
    }
  } catch (error) {
    console.error(`加载项目 "${projectName}" 的路由失败:`, error)
    throw error
  }
}

/**
 * 为路由添加项目前缀
 * @param {Object} route - 路由对象
 * @param {string} projectName - 项目名称
 * @returns {Object} 带前缀的路由对象
 */
function addProjectPrefix(route, projectName) {
  return {
    ...route,
    path: route.path === '/' ? `/${projectName}` : `/${projectName}${route.path}`
  }
}

/**
 * 为默认项目创建根路径访问路由
 * @param {string} projectName - 项目名称
 * @returns {Promise<Array>} 默认项目路由数组
 */
async function createDefaultProjectRoutes(projectName) {
  const defaultProject = import.meta.env.VITE_ACTIVE_PROJECT || DEFAULT_PROJECT
  
  // 只为默认项目创建根路径路由
  if (projectName !== defaultProject) {
    return []
  }
  
  try {
    const { routes } = await loadProjectRoutes(projectName)
    
    // 为默认项目创建无前缀的路由副本
    return routes.map(route => createDefaultRoute(route, projectName))
  } catch (error) {
    console.error(`创建默认项目路由失败:`, error)
    return []
  }
}

/**
 * 创建默认路由（移除项目前缀）
 * @param {Object} route - 原始路由对象
 * @param {string} projectName - 项目名称
 * @returns {Object} 默认路由对象
 */
function createDefaultRoute(route, projectName) {
  return {
    ...route,
    path: route.path.replace(`/${projectName}`, '') || '/',
    name: `Default${route.name || 'Route'}`,
    meta: {
      ...route.meta,
      isDefaultProject: true
    }
  }
}

// 创建路由实例
let router = null

export async function createAppRouter() {
  const activeProject = getActiveProject()
  const defaultProject = import.meta.env.VITE_ACTIVE_PROJECT || 'project_01'
  
  try {
    const { routes: projectRoutes, config } = await loadProjectRoutes(activeProject)
    
    // 为默认项目创建根路径路由
    const defaultProjectRoutes = activeProject === defaultProject 
      ? await createDefaultProjectRoutes(activeProject)
      : []
    
    // 基础路由
    const routes = [
      // 项目切换页面（支持hash和history模式）
      {
        path: '/projects',
        name: 'ProjectSwitcher',
        component: () => import('@/components/ProjectSwitcher.vue')
      },
      // 默认项目的根路径路由（如果当前是默认项目）
      ...defaultProjectRoutes,
      // 所有项目的带前缀路由
      ...projectRoutes,
      // 根路径重定向逻辑
      {
        path: '/',
        redirect: () => {
          const current = getActiveProject()
          return current === defaultProject ? `/${defaultProject}` : `/${current}`
        }
      },
      // 404页面
      {
        path: '/:pathMatch(.*)*',
        name: 'NotFound',
        component: () => import('@/components/NotFound.vue')
      }
    ]
    
    router = createRouter({
      history,
      routes
    })
    
    // 应用项目配置的路由守卫
    if (config.beforeEach) {
      router.beforeEach(config.beforeEach)
    }
    
    if (config.afterEach) {
      router.afterEach(config.afterEach)
    }
    
    console.log(`已加载项目: ${activeProject}`)
    return router
    
  } catch (error) {
    console.error('创建路由失败:', error)
    // 创建一个最小路由作为回退
    return createRouter({
      history,
      routes: [
        {
          path: '/',
          component: () => import('@/components/ProjectError.vue')
        }
      ]
    })
  }
}

/**
 * 切换到指定项目
 * @param {string} projectName - 目标项目名称
 * @returns {Promise<boolean>} 切换是否成功
 */
export async function switchProject(projectName) {
  // 验证项目是否存在
  if (!isValidProject(projectName)) {
    console.warn(`项目 "${projectName}" 不存在`)
    return false
  }
  
  // 更新存储的项目信息
  saveProjectToStorage(projectName)
  
  // 构建并跳转到新URL
  const newUrl = buildProjectUrl(projectName)
  navigateToUrl(newUrl)
  
  return true
}

/**
 * 验证项目是否有效
 * @param {string} projectName - 项目名称
 * @returns {boolean} 是否有效
 */
function isValidProject(projectName) {
  const availableProjects = getAvailableProjects()
  return availableProjects.includes(projectName)
}

/**
 * 构建项目URL
 * @param {string} projectName - 项目名称
 * @returns {URL} 构建的URL对象
 */
function buildProjectUrl(projectName) {
  const url = new URL(window.location)
  const defaultProject = import.meta.env.VITE_ACTIVE_PROJECT || DEFAULT_PROJECT
  const currentRouterMode = getRouterMode()
  
  // 清除project参数
  url.searchParams.delete('project')
  
  if (projectName === defaultProject) {
    // 默认项目使用根路径
    url.pathname = '/'
    url.hash = currentRouterMode === ROUTER_MODES.HASH ? '#/' : ''
  } else {
    // 非默认项目使用项目前缀
    url.pathname = `/${projectName}`
    url.hash = currentRouterMode === ROUTER_MODES.HASH ? `#/${projectName}` : ''
  }
  
  return url
}

/**
 * 导航到指定URL
 * @param {URL} url - 目标URL
 */
function navigateToUrl(url) {
  window.history.pushState({}, '', url)
  window.location.reload()
}

/**
 * 切换路由模式（需要重新构建应用生效）
 * @param {string} newMode - 新的路由模式 ('hash' | 'history')
 * @returns {string} 返回设置的模式
 * @throws {Error} 当模式无效时抛出错误
 */
export function switchRouterMode(newMode) {
  // 验证路由模式
  if (!Object.values(ROUTER_MODES).includes(newMode)) {
    throw new Error(`路由模式只能是 ${Object.values(ROUTER_MODES).join(' 或 ')}`)
  }
  
  // 注意：这里只是演示，实际环境变量需要在构建时确定
  // 在实际应用中，可以通过重新构建或服务器端配置来切换模式
  console.warn('路由模式切换需要重新构建应用或修改环境变量后重启开发服务器')
  return newMode
}

// 导出路由模式相关函数
export { getRouterMode, createRouterHistory }

export { router }
export default router